/*!
 * c17_boolean_basics - 布尔类型：true与false
 * 
 * 《Rust基础数据类型实战Cookbook》系列第17个案例
 * 全面掌握 Rust 中的布尔类型，理解 true 和 false 的使用方法和应用场景
 * 
 * 本案例涵盖：
 * - 布尔类型基础概念和特性
 * - 布尔值的声明、赋值和使用
 * - 布尔值的内存表示和大小
 * - 布尔值与其他类型的转换
 * - 布尔值在条件判断中的应用
 * - 布尔值的格式化输出
 * - 实际编程场景中的应用技巧
 */

fn main() {
    println!("=== Rust 布尔类型详解 ===\n");
    
    // 1. 布尔类型概述
    demonstrate_bool_overview();
    println!();
    
    // 2. 布尔值声明和赋值
    demonstrate_bool_declaration();
    println!();
    
    // 3. 布尔值内存表示
    demonstrate_bool_memory_layout();
    println!();
    
    // 4. 布尔值与其他类型转换
    demonstrate_bool_conversion();
    println!();
    
    // 5. 布尔值比较操作
    demonstrate_bool_comparison();
    println!();
    
    // 6. 布尔值在条件表达式中的应用
    demonstrate_bool_conditional();
    println!();
    
    // 7. 布尔值格式化输出
    demonstrate_bool_formatting();
    println!();
    
    // 8. 实际应用场景
    demonstrate_practical_applications();
    println!();
    
    println!("=== 布尔类型学习完成！===");
}

/// 1. 演示布尔类型的基础概念
fn demonstrate_bool_overview() {
    println!("1. 布尔类型概述");
    println!("   布尔类型(bool)是 Rust 中最简单的数据类型，只有两个可能的值：true 和 false");
    println!("   用于表示逻辑状态、条件判断和二元选择");
    println!();
    
    println!("1.1 基本概念展示");
    
    // 布尔类型的两个值
    let is_true = true;
    let is_false = false;
    
    println!("   true 值: {}", is_true);
    println!("   false 值: {}", is_false);
    println!("   true 的类型: {:?}", std::any::type_name_of_val(&is_true));
    println!("   false 的类型: {:?}", std::any::type_name_of_val(&is_false));
    println!();
    
    println!("1.2 为什么需要布尔类型？");
    println!("   • 表示逻辑状态：开/关、是/否、成功/失败");
    println!("   • 控制程序流程：条件判断、循环控制");
    println!("   • 配置和标志：功能开关、权限控制");
    println!("   • 逻辑运算：与或非操作的基础");
    println!();
    
    println!("1.3 布尔类型特性");
    println!("   • 类型名称：bool");
    println!("   • 可能值：true, false");
    println!("   • 内存大小：1 字节");
    println!("   • 对齐要求：1 字节");
    println!("   • Copy trait：自动实现");
}

/// 2. 演示布尔值的声明和赋值
fn demonstrate_bool_declaration() {
    println!("2. 布尔值声明和赋值");
    println!("   学习各种布尔值声明、初始化和赋值的方式");
    println!();
    
    println!("2.1 直接声明");
    // 显式类型声明
    let explicit_true: bool = true;
    let explicit_false: bool = false;
    println!("   显式声明 true: let explicit_true: bool = true; // {}", explicit_true);
    println!("   显式声明 false: let explicit_false: bool = false; // {}", explicit_false);
    println!();
    
    // 类型推断
    let inferred_true = true;
    let inferred_false = false;
    println!("   类型推断 true: let inferred_true = true; // {}", inferred_true);
    println!("   类型推断 false: let inferred_false = false; // {}", inferred_false);
    println!();
    
    println!("2.2 通过表达式赋值");
    // 比较表达式
    let is_greater = 10 > 5;
    let is_equal = 3 == 3;
    let is_less = 7 < 2;
    println!("   比较结果 (10 > 5): {}", is_greater);
    println!("   相等判断 (3 == 3): {}", is_equal);
    println!("   小于判断 (7 < 2): {}", is_less);
    println!();
    
    // 逻辑表达式
    let both_true = true && true;
    let either_true = true || false;
    let not_true = !true;
    println!("   逻辑与 (true && true): {}", both_true);
    println!("   逻辑或 (true || false): {}", either_true);
    println!("   逻辑非 (!true): {}", not_true);
    println!();
    
    println!("2.3 可变性");
    let mut mutable_flag = true;
    println!("   初始值: {}", mutable_flag);
    mutable_flag = false;
    println!("   修改后: {}", mutable_flag);
    mutable_flag = !mutable_flag;
    println!("   取反后: {}", mutable_flag);
}

/// 3. 演示布尔值的内存表示
fn demonstrate_bool_memory_layout() {
    println!("3. 布尔值内存表示");
    println!("   探索布尔值在内存中的存储方式和特性");
    println!();
    
    println!("3.1 内存大小");
    // 查看布尔值的内存大小
    println!("   bool 类型大小: {} 字节", std::mem::size_of::<bool>());
    println!("   bool 类型对齐: {} 字节", std::mem::align_of::<bool>());
    println!();
    
    println!("3.2 内存地址和值");
    let true_value = true;
    let false_value = false;
    
    // 显示内存地址
    println!("   true 值的地址: {:p}", &true_value);
    println!("   false 值的地址: {:p}", &false_value);
    println!();
    
    // 将布尔值转换为原始字节查看
    let true_as_u8 = u8::from(true_value);
    let false_as_u8 = u8::from(false_value);
    println!("   true 的字节表示: {:#04x} ({})", true_as_u8, true_as_u8);
    println!("   false 的字节表示: {:#04x} ({})", false_as_u8, false_as_u8);
    println!();
    
    println!("3.3 数组中的布尔值");
    let bool_array = [true, false, true, false];
    println!("   布尔数组: {:?}", bool_array);
    println!("   数组总大小: {} 字节", std::mem::size_of_val(&bool_array));
    println!("   每个元素大小: {} 字节", std::mem::size_of::<bool>());
    println!("   数组长度: {} 个元素", bool_array.len());
}

/// 4. 演示布尔值与其他类型的转换
fn demonstrate_bool_conversion() {
    println!("4. 布尔值与其他类型转换");
    println!("   学习布尔值与整数、字符串等类型之间的转换方法");
    println!();
    
    println!("4.1 布尔值转换为数字");
    let true_bool = true;
    let false_bool = false;
    
    // 转换为整数
    let true_as_u8 = true_bool as u8;
    let false_as_u8 = false_bool as u8;
    let true_as_i32 = true_bool as i32;
    let false_as_i32 = false_bool as i32;
    
    println!("   true as u8: {}", true_as_u8);
    println!("   false as u8: {}", false_as_u8);
    println!("   true as i32: {}", true_as_i32);
    println!("   false as i32: {}", false_as_i32);
    println!();
    
    println!("4.2 数字转换为布尔值");
    // 注意：Rust 不会自动将数字转换为布尔值
    // 需要显式比较
    let zero = 0;
    let non_zero = 42;
    let zero_as_bool = zero != 0;
    let non_zero_as_bool = non_zero != 0;
    
    println!("   0 != 0: {}", zero_as_bool);
    println!("   42 != 0: {}", non_zero_as_bool);
    println!();
    
    println!("4.3 布尔值转换为字符串");
    let true_string = true.to_string();
    let false_string = false.to_string();
    let formatted_true = format!("{}", true);
    let formatted_false = format!("{}", false);
    
    println!("   true.to_string(): \"{}\"", true_string);
    println!("   false.to_string(): \"{}\"", false_string);
    println!("   format!(\"true\"): \"{}\"", formatted_true);
    println!("   format!(\"false\"): \"{}\"", formatted_false);
    println!();
    
    println!("4.4 字符串解析为布尔值");
    let parse_true = "true".parse::<bool>();
    let parse_false = "false".parse::<bool>();
    let parse_invalid = "maybe".parse::<bool>();
    
    match parse_true {
        Ok(value) => println!("   \"true\".parse(): Ok({})", value),
        Err(e) => println!("   \"true\".parse(): Err({})", e),
    }
    
    match parse_false {
        Ok(value) => println!("   \"false\".parse(): Ok({})", value),
        Err(e) => println!("   \"false\".parse(): Err({})", e),
    }
    
    match parse_invalid {
        Ok(value) => println!("   \"maybe\".parse(): Ok({})", value),
        Err(e) => println!("   \"maybe\".parse(): Err({})", e),
    }
}

/// 5. 演示布尔值比较操作
fn demonstrate_bool_comparison() {
    println!("5. 布尔值比较操作");
    println!("   探索布尔值之间的比较、排序和相等性判断");
    println!();
    
    println!("5.1 相等性比较");
    let a = true;
    let b = false;
    let c = true;
    
    println!("   {} == {}: {}", a, b, a == b);
    println!("   {} == {}: {}", a, c, a == c);
    println!("   {} != {}: {}", a, b, a != b);
    println!("   {} != {}: {}", a, c, a != c);
    println!();
    
    println!("5.2 布尔值排序");
    // 在 Rust 中，false < true
    let mut bool_vec = vec![true, false, true, false, true];
    println!("   排序前: {:?}", bool_vec);
    
    bool_vec.sort();
    println!("   排序后: {:?}", bool_vec);
    println!("   排序规则: false < true");
    println!();
    
    println!("5.3 布尔值比较详解");
    println!("   false < true: {}", false < true);
    println!("   true < false: {}", true < false);
    println!("   false <= false: {}", false <= false);
    println!("   true >= true: {}", true >= true);
    println!();
    
    println!("5.4 使用比较结果");
    let values = [true, false, true, false];
    let true_count = values.iter().filter(|&&x| x == true).count();
    let false_count = values.iter().filter(|&&x| x == false).count();
    
    println!("   数组: {:?}", values);
    println!("   true 的数量: {}", true_count);
    println!("   false 的数量: {}", false_count);
}

/// 6. 演示布尔值在条件表达式中的应用
fn demonstrate_bool_conditional() {
    println!("6. 布尔值在条件表达式中的应用");
    println!("   学习布尔值在 if/else、match、循环等控制结构中的使用");
    println!();
    
    println!("6.1 if/else 条件判断");
    let is_sunny = true;
    let temperature = 25;
    
    if is_sunny {
        println!("   天气晴朗，适合外出！");
    } else {
        println!("   天气不好，建议待在室内。");
    }
    
    let weather_advice = if is_sunny && temperature > 20 {
        "完美的外出天气"
    } else if is_sunny && temperature <= 20 {
        "有点凉，需要加衣服"
    } else {
        "不太适合外出"
    };
    println!("   天气建议: {}", weather_advice);
    println!();
    
    println!("6.2 条件表达式返回值");
    let number = 42;
    let is_even = number % 2 == 0;
    let parity = if is_even { "偶数" } else { "奇数" };
    
    println!("   数字 {} 是: {}", number, parity);
    println!();
    
    println!("6.3 match 表达式");
    let success = true;
    let result_message = match success {
        true => "操作成功！",
        false => "操作失败！",
    };
    println!("   匹配结果: {}", result_message);
    println!();
    
    println!("6.4 复杂条件组合");
    let user_age = 25;
    let has_license = true;
    let has_insurance = true;
    let has_car = false;
    
    let can_drive = user_age >= 18 && has_license;
    let can_drive_legally = can_drive && has_insurance;
    let can_actually_drive = can_drive_legally && has_car;
    
    println!("   年龄: {}", user_age);
    println!("   有驾照: {}", has_license);
    println!("   有保险: {}", has_insurance);
    println!("   有车: {}", has_car);
    println!("   可以开车: {}", can_drive);
    println!("   可以合法开车: {}", can_drive_legally);
    println!("   实际能开车: {}", can_actually_drive);
    println!();
    
    println!("6.5 while 循环中的布尔条件");
    let mut counter = 0;
    let mut continue_loop = true;
    
    println!("   计数演示:");
    while continue_loop && counter < 5 {
        println!("     计数器: {}", counter);
        counter += 1;
        if counter >= 3 {
            continue_loop = false;
        }
    }
    println!("   循环结束，最终计数: {}", counter);
}

/// 7. 演示布尔值格式化输出
fn demonstrate_bool_formatting() {
    println!("7. 布尔值格式化输出");
    println!("   学习各种布尔值的显示和调试输出方式");
    println!();
    
    println!("7.1 基本格式化");
    let true_val = true;
    let false_val = false;
    
    println!("   Display 格式: {} / {}", true_val, false_val);
    println!("   Debug 格式: {:?} / {:?}", true_val, false_val);
    println!();
    
    println!("7.2 条件格式化");
    let status = true;
    let status_text = if status { "启用" } else { "禁用" };
    let status_symbol = if status { "✓" } else { "✗" };
    let status_color = if status { "绿色" } else { "红色" };
    
    println!("   功能状态: {} ({})", status_text, status_symbol);
    println!("   显示颜色: {}", status_color);
    println!();
    
    println!("7.3 集合中的布尔值格式化");
    let flags = vec![true, false, true, true, false];
    let settings = [
        ("音量", true),
        ("震动", false),
        ("通知", true),
        ("自动更新", false),
    ];
    
    println!("   标志数组: {:?}", flags);
    println!("   设置列表:");
    for (name, enabled) in &settings {
        let status = if *enabled { "开启" } else { "关闭" };
        println!("     {}: {}", name, status);
    }
    println!();
    
    println!("7.4 布尔值统计显示");
    let test_results = [true, true, false, true, false, true, true, false, true];
    let passed = test_results.iter().filter(|&&x| x).count();
    let failed = test_results.iter().filter(|&&x| !x).count();
    let total = test_results.len();
    let pass_rate = passed as f64 / total as f64 * 100.0;
    
    println!("   测试结果: {:?}", test_results);
    println!("   通过: {} 个", passed);
    println!("   失败: {} 个", failed);
    println!("   总计: {} 个", total);
    println!("   通过率: {:.1}%", pass_rate);
}

/// 8. 演示实际应用场景
fn demonstrate_practical_applications() {
    println!("8. 实际应用场景");
    println!("   展示布尔值在实际编程中的常见应用模式和最佳实践");
    println!();
    
    println!("8.1 配置管理");
    // 模拟应用程序配置
    #[derive(Debug)]
    struct AppConfig {
        debug_mode: bool,
        auto_save: bool,
        show_notifications: bool,
        use_dark_theme: bool,
        enable_logging: bool,
    }
    
    let config = AppConfig {
        debug_mode: true,
        auto_save: true,
        show_notifications: false,
        use_dark_theme: true,
        enable_logging: true,
    };
    
    println!("   应用配置: {:?}", config);
    
    // 根据配置做出决策
    if config.debug_mode {
        println!("   [DEBUG] 调试模式已启用");
    }
    
    if config.auto_save && config.enable_logging {
        println!("   [INFO] 自动保存功能启用，日志记录开启");
    }
    
    if config.show_notifications {
        println!("   [INFO] 通知功能已启用");
    }
    
    if config.use_dark_theme {
        println!("   [INFO] 使用深色主题");
    }
    println!();
    
    println!("8.2 状态管理");
    // 模拟用户状态
    struct UserState {
        is_logged_in: bool,
        is_premium: bool,
        has_unread_messages: bool,
        is_online: bool,
    }
    
    let user = UserState {
        is_logged_in: true,
        is_premium: false,
        has_unread_messages: true,
        is_online: true,
    };
    
    // 权限检查
    let can_access_premium = user.is_logged_in && user.is_premium;
    let show_message_indicator = user.is_logged_in && user.has_unread_messages;
    let user_status = if user.is_online { "在线" } else { "离线" };
    
    println!("   用户登录状态: {}", user.is_logged_in);
    println!("   用户状态: {}", user_status);
    println!("   可访问高级功能: {}", can_access_premium);
    println!("   显示消息提醒: {}", show_message_indicator);
    println!();
    
    println!("8.3 验证和检查");
    // 输入验证
    fn validate_user_input(email: &str, password: &str, age: u8) -> (bool, Vec<String>) {
        let mut errors = Vec::new();
        let mut is_valid = true;
        
        let has_at_symbol = email.contains('@');
        let has_dot = email.contains('.');
        let email_valid = has_at_symbol && has_dot && email.len() > 5;
        
        let password_long_enough = password.len() >= 8;
        let has_number = password.chars().any(|c| c.is_numeric());
        let has_letter = password.chars().any(|c| c.is_alphabetic());
        let password_valid = password_long_enough && has_number && has_letter;
        
        let age_valid = age >= 13 && age <= 120;
        
        if !email_valid {
            errors.push("邮箱格式不正确".to_string());
            is_valid = false;
        }
        
        if !password_valid {
            errors.push("密码必须至少8位，包含数字和字母".to_string());
            is_valid = false;
        }
        
        if !age_valid {
            errors.push("年龄必须在13-120之间".to_string());
            is_valid = false;
        }
        
        (is_valid, errors)
    }
    
    let (valid, errors) = validate_user_input("user@example.com", "password123", 25);
    println!("   输入验证结果: {}", if valid { "通过" } else { "失败" });
    if !errors.is_empty() {
        println!("   错误信息: {:?}", errors);
    }
    println!();
    
    println!("8.4 控制流程");
    // 任务处理流程
    let mut task_completed = false;
    let mut retry_count = 0;
    let max_retries = 3;
    let simulate_failure = true;
    
    println!("   任务执行流程:");
    while !task_completed && retry_count < max_retries {
        retry_count += 1;
        println!("     尝试第 {} 次", retry_count);
        
        // 模拟任务执行
        let success = if simulate_failure && retry_count < 3 {
            false
        } else {
            true
        };
        
        if success {
            task_completed = true;
            println!("     任务执行成功！");
        } else {
            println!("     任务执行失败，准备重试...");
        }
    }
    
    let final_result = if task_completed {
        "任务最终完成"
    } else {
        "任务最终失败，已达到最大重试次数"
    };
    println!("   最终结果: {}", final_result);
    println!();
    
    println!("8.5 特性开关(Feature Flags)");
    // 模拟功能开关
    struct FeatureFlags {
        new_ui: bool,
        beta_features: bool,
        advanced_analytics: bool,
        experimental_mode: bool,
    }
    
    let features = FeatureFlags {
        new_ui: true,
        beta_features: false,
        advanced_analytics: true,
        experimental_mode: false,
    };
    
    println!("   功能开关状态:");
    println!("     新版UI: {}", if features.new_ui { "启用" } else { "禁用" });
    println!("     测试功能: {}", if features.beta_features { "启用" } else { "禁用" });
    println!("     高级分析: {}", if features.advanced_analytics { "启用" } else { "禁用" });
    println!("     实验模式: {}", if features.experimental_mode { "启用" } else { "禁用" });
    
    // 根据特性开关执行不同逻辑
    if features.new_ui {
        println!("   > 加载新版用户界面");
    }
    
    if features.advanced_analytics && !features.experimental_mode {
        println!("   > 启用高级数据分析功能");
    }
    
    if features.beta_features {
        println!("   > 解锁测试版功能");
    } else {
        println!("   > 使用稳定版功能");
    }
}
